home *** CD-ROM | disk | FTP | other *** search
/ Skunkware 5 / Skunkware 5.iso / src / Games / xpipeman / graphics.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-05-03  |  14.7 KB  |  458 lines
  1. /*
  2.  * graphics.c  - Xpipeman
  3.  *
  4.  * Send Constructive comments, bug reports, etc. to either
  5.  *
  6.  *          JANET: pavern@uk.ac.man.cs
  7.  *
  8.  *  or      INER : pavern%cs.man.ac.uk@nsfnet-relay.ac.uk
  9.  *
  10.  * All other comments > /dev/null !!
  11.  * 
  12.  * Copyright 1991 Nigel Paver
  13.  * 
  14.  * Permission to use, copy, modify, distribute, and sell this software and its
  15.  * documentation for any purpose is hereby granted without fee, provided that
  16.  * the above copyright notice appear in all copies and that both that
  17.  * copyright notice and this permission notice appear in supporting
  18.  * documentation, and that the author's name not be used in advertising or
  19.  * publicity pertaining to distribution of the software without specific,
  20.  * written prior permission.  The author makes no representations about the
  21.  * suitability of this software for any purpose.  It is provided "as is"
  22.  * without express or implied warranty.
  23.  * 
  24.  * THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING 
  25.  * ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL THE 
  26.  * AUTHOR BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY 
  27.  * DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN 
  28.  * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF 
  29.  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  30.  * 
  31.  *
  32.  *
  33.  * Acknowledgements to Brian Warkentine (brian@sun.COM) for his xrobots
  34.  * program (copyright  1989) which I cannibalized to write this program
  35.  */
  36.  
  37. #include <X11/X.h>
  38. #include <X11/Intrinsic.h>
  39. #include <X11/Shell.h>
  40. #include "xpipeman.h"
  41. #include "bitmaps1.h"
  42. #include "bitmaps2.h"
  43. #include "icon.h"
  44.  
  45. static Pixmap iconP;
  46.  
  47.  
  48. static Pixmap tmp_pixmap[NUM_TMP_CURSOR_PIXMAPS]; 
  49.  
  50. /*----------------------------------------------------------------------*/
  51.  
  52. void
  53. init_pixmaps(top_shell)
  54.   Widget top_shell;
  55. {
  56. /*
  57.  * Let's make some pixmaps and some cursors.
  58.  * And then let's set the iconpixmap.
  59.  */
  60.   Pixmap tmpP;
  61.   XColor fgcolor,bgcolor;
  62.   Arg arg;
  63.  
  64. /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
  65.  
  66.   fgcolor.pixel = fg;
  67.   bgcolor.pixel = bg;
  68.   fgcolor.flags =  DoRed | DoGreen | DoBlue;
  69.   bgcolor.flags =  DoRed | DoGreen | DoBlue;
  70.   XQueryColor(display,DefaultColormapOfScreen(XtScreen(playfield_widget)), &fgcolor);
  71.   XQueryColor(display,DefaultColormapOfScreen(XtScreen(playfield_widget)), &bgcolor);
  72.  
  73.  
  74.   iconP =  XCreateBitmapFromData(display,playfield,
  75.                icon_bits,icon_width,icon_height);
  76.  
  77.   tmp_pixmap[EMPTY] = XCreateBitmapFromData(display,playfield,
  78.                empty_bits, empty_width, empty_height);
  79.  
  80.   tmp_pixmap[1] = XCreateBitmapFromData(display,playfield, b1_bits,
  81.                     b1_width, b1_height);
  82.  
  83.   tmp_pixmap[2] = XCreateBitmapFromData(display,playfield, b2_bits,
  84.                     b2_width, b2_height);
  85.  
  86.   tmp_pixmap[3] = XCreateBitmapFromData(display,playfield, b3_bits,
  87.                     b3_width, b3_height);
  88.  
  89.   tmp_pixmap[4] = XCreateBitmapFromData(display,playfield, b4_bits,
  90.                     b4_width, b4_height);
  91.  
  92.   tmp_pixmap[5] = XCreateBitmapFromData(display,playfield, b5_bits,
  93.                     b5_width, b5_height);
  94.  
  95.   tmp_pixmap[6] = XCreateBitmapFromData(display,playfield, b6_bits,
  96.                     b6_width, b6_height);
  97.  
  98.   tmp_pixmap[7] = XCreateBitmapFromData(display,playfield, b7_bits,
  99.                     b7_width, b7_height);
  100.  
  101.   tmp_pixmap[ONEWAY] = XCreateBitmapFromData(display,playfield, b11w_bits,
  102.                     b11w_width, b11w_height);
  103.  
  104.   tmp_pixmap[ONEWAY+1] = XCreateBitmapFromData(display,playfield, b21w_bits,
  105.                     b21w_width, b21w_height);
  106.  
  107.   tmp_pixmap[ONEWAY+2] = XCreateBitmapFromData(display,playfield, b31w_bits,
  108.                     b31w_width, b31w_height);
  109.  
  110.   tmp_pixmap[ONEWAY+3] = XCreateBitmapFromData(display,playfield, b41w_bits,
  111.                     b41w_width, b41w_height);
  112.  
  113.   tmp_pixmap[ONEWAY+4] = XCreateBitmapFromData(display,playfield, b51w_bits,
  114.                     b51w_width, b51w_height);
  115.  
  116.   tmp_pixmap[ONEWAY+5] = XCreateBitmapFromData(display,playfield, b61w_bits,
  117.                     b61w_width, b61w_height);
  118.  
  119.   tmp_pixmap[HFULL] = XCreateBitmapFromData(display,playfield, b8_bits,
  120.                     b8_width, b8_height);
  121.  
  122.   tmp_pixmap[VFULL] = XCreateBitmapFromData(display,playfield, b9_bits,
  123.                     b9_width, b9_height);
  124.  
  125.   tmp_pixmap[FILLBLKSTART] = XCreateBitmapFromData(display,playfield, b11_bits,
  126.                     block_width, block_height);
  127.  
  128.   tmp_pixmap[FILLBLKSTART+1] = XCreateBitmapFromData(display,playfield, b12_bits,
  129.                     block_width, block_height);
  130.  
  131.   tmp_pixmap[FILLBLKSTART+2] = XCreateBitmapFromData(display,playfield, b13_bits,
  132.                     block_width, block_height);
  133.  
  134.   tmp_pixmap[FILLBLKSTART+3] = XCreateBitmapFromData(display,playfield, b14_bits,
  135.                     block_width, block_height);
  136.  
  137.   tmp_pixmap[FILLBLKSTART+4] = XCreateBitmapFromData(display,playfield, b15_bits,
  138.                     block_width, block_height);
  139.  
  140.   tmp_pixmap[FILLBLKSTART+5] = XCreateBitmapFromData(display,playfield, b21_bits,
  141.                     block_width, block_height);
  142.  
  143.   tmp_pixmap[FILLBLKSTART+6] = XCreateBitmapFromData(display,playfield, b22_bits,
  144.                     block_width, block_height);
  145.  
  146.   tmp_pixmap[FILLBLKSTART+7] = XCreateBitmapFromData(display,playfield, b23_bits,
  147.                     block_width, block_height);
  148.  
  149.   tmp_pixmap[FILLBLKSTART+8] = XCreateBitmapFromData(display,playfield, b24_bits,
  150.                     block_width, block_height);
  151.  
  152.   tmp_pixmap[FILLBLKSTART+9] = XCreateBitmapFromData(display,playfield, b25_bits,
  153.                     block_width, block_height);
  154.  
  155.   tmp_pixmap[FILLBLKSTART+10] = XCreateBitmapFromData(display,playfield, b31_bits,
  156.                     block_width, block_height);
  157.  
  158.   tmp_pixmap[FILLBLKSTART+11] = XCreateBitmapFromData(display,playfield, b32_bits,
  159.                     block_width, block_height);
  160.  
  161.   tmp_pixmap[FILLBLKSTART+12] = XCreateBitmapFromData(display,playfield, b33_bits,
  162.                 block_width, block_height);
  163.  
  164.   tmp_pixmap[FILLBLKSTART+13] = XCreateBitmapFromData(display,playfield, b34_bits,
  165.                     block_width, block_height);
  166.  
  167.   tmp_pixmap[FILLBLKSTART+14] = XCreateBitmapFromData(display,playfield, b35_bits,
  168.                     block_width, block_height);
  169.  
  170.   tmp_pixmap[FILLBLKSTART+15] = XCreateBitmapFromData(display,playfield, b41_bits,
  171.                     block_width, block_height);
  172.  
  173.   tmp_pixmap[FILLBLKSTART+16] = XCreateBitmapFromData(display,playfield, b42_bits,
  174.                     block_width, block_height);
  175.  
  176.   tmp_pixmap[FILLBLKSTART+17] = XCreateBitmapFromData(display,playfield, b43_bits,
  177.                     block_width, block_height);
  178.  
  179.   tmp_pixmap[FILLBLKSTART+18] = XCreateBitmapFromData(display,playfield, b44_bits,
  180.                     block_width, block_height);
  181.  
  182.   tmp_pixmap[FILLBLKSTART+19] = XCreateBitmapFromData(display,playfield, b45_bits,
  183.                     block_width, block_height);
  184.  
  185.   tmp_pixmap[FILLBLKSTART+20] = XCreateBitmapFromData(display,playfield, b51_bits,
  186.                     block_width, block_height);
  187.  
  188.   tmp_pixmap[FILLBLKSTART+21] = XCreateBitmapFromData(display,playfield, b52_bits,
  189.                     block_width, block_height);
  190.  
  191.   tmp_pixmap[FILLBLKSTART+22] = XCreateBitmapFromData(display,playfield, b53_bits,
  192.                     block_width, block_height);
  193.  
  194.   tmp_pixmap[FILLBLKSTART+23] = XCreateBitmapFromData(display,playfield, b54_bits,
  195.                     block_width, block_height);
  196.  
  197.   tmp_pixmap[FILLBLKSTART+24] = XCreateBitmapFromData(display,playfield, b55_bits,
  198.                     block_width, block_height);
  199.  
  200.   tmp_pixmap[FILLBLKSTART+25] = XCreateBitmapFromData(display,playfield, b61_bits,
  201.                     block_width, block_height);
  202.  
  203.   tmp_pixmap[FILLBLKSTART+26] = XCreateBitmapFromData(display,playfield, b62_bits,
  204.                     block_width, block_height);
  205.  
  206.   tmp_pixmap[FILLBLKSTART+27] = XCreateBitmapFromData(display,playfield, b63_bits,
  207.                     block_width, block_height);
  208.  
  209.   tmp_pixmap[FILLBLKSTART+28] = XCreateBitmapFromData(display,playfield, b64_bits,
  210.                     block_width, block_height);
  211.  
  212.   tmp_pixmap[FILLBLKSTART+29] = XCreateBitmapFromData(display,playfield, b65_bits,
  213.                     block_width, block_height);
  214.  
  215.   tmp_pixmap[FILLBLKSTART+30] = XCreateBitmapFromData(display,playfield, b71_bits,
  216.                     block_width, block_height);
  217.  
  218.   tmp_pixmap[FILLBLKSTART+31] = XCreateBitmapFromData(display,playfield, b72_bits,
  219.                     block_width, block_height);
  220.  
  221.   tmp_pixmap[FILLBLKSTART+32] = XCreateBitmapFromData(display,playfield, b73_bits,
  222.                     block_width, block_height);
  223.  
  224.   tmp_pixmap[FILLBLKSTART+33] = XCreateBitmapFromData(display,playfield, b74_bits,
  225.                     block_width, block_height);
  226.  
  227.   tmp_pixmap[FILLBLKSTART+34] = XCreateBitmapFromData(display,playfield, b75_bits,
  228.                     block_width, block_height);
  229.  
  230.   tmp_pixmap[FILLBLKSTART+35] = XCreateBitmapFromData(display,playfield, b76_bits,
  231.                     block_width, block_height);
  232.  
  233.   tmp_pixmap[FILLBLKSTART+36] = XCreateBitmapFromData(display,playfield, b77_bits,
  234.                     block_width, block_height);
  235.  
  236.   tmp_pixmap[FILLBLKSTART+37] = XCreateBitmapFromData(display,playfield, b78_bits,
  237.                     block_width, block_height);
  238.  
  239.   tmp_pixmap[FILLBLKSTART+38] = XCreateBitmapFromData(display,playfield, b79_bits,
  240.                     block_width, block_height);
  241.  
  242.   tmp_pixmap[FILLBLKSTART+39] = XCreateBitmapFromData(display,playfield, b7a_bits,
  243.                     block_width, block_height);
  244.  
  245.   tmp_pixmap[FILLBLKSTART+40] = XCreateBitmapFromData(display,playfield, b81_bits,
  246.                     block_width, block_height);
  247.  
  248.   tmp_pixmap[FILLBLKSTART+41] = XCreateBitmapFromData(display,playfield, b82_bits,
  249.                     block_width, block_height);
  250.  
  251.   tmp_pixmap[FILLBLKSTART+42] = XCreateBitmapFromData(display,playfield, b83_bits,
  252.                     block_width, block_height);
  253.  
  254.   tmp_pixmap[FILLBLKSTART+43] = XCreateBitmapFromData(display,playfield, b84_bits,
  255.                     block_width, block_height);
  256.  
  257.   tmp_pixmap[FILLBLKSTART+44] = XCreateBitmapFromData(display,playfield, b85_bits,
  258.                     block_width, block_height);
  259.  
  260.   tmp_pixmap[FILLBLKSTART+45] = XCreateBitmapFromData(display,playfield, b91_bits,
  261.                     block_width, block_height);
  262.  
  263.   tmp_pixmap[FILLBLKSTART+46] = XCreateBitmapFromData(display,playfield, b92_bits,
  264.                     block_width, block_height);
  265.  
  266.   tmp_pixmap[FILLBLKSTART+47] = XCreateBitmapFromData(display,playfield, b93_bits,
  267.                     block_width, block_height);
  268.  
  269.   tmp_pixmap[FILLBLKSTART+48] = XCreateBitmapFromData(display,playfield, b94_bits,
  270.                     block_width, block_height);
  271.  
  272.   tmp_pixmap[FILLBLKSTART+49] = XCreateBitmapFromData(display,playfield, b95_bits,
  273.                     block_width, block_height);
  274.  
  275.   tmp_pixmap[OBSRT] = XCreateBitmapFromData(display,playfield, ob1_bits,
  276.                     block_width, block_height);
  277.  
  278.   tmp_pixmap[OBSRT+1] = XCreateBitmapFromData(display,playfield, ob2_bits,
  279.                     block_width, block_height);
  280.  
  281.   tmp_pixmap[OBSRT+2] = XCreateBitmapFromData(display,playfield, ob3_bits,
  282.                     block_width, block_height);
  283.  
  284.   tmp_pixmap[OBSRT+3] = XCreateBitmapFromData(display,playfield, ob4_bits,
  285.                     block_width, block_height);
  286.  
  287.   tmp_pixmap[OBSRT+4] = XCreateBitmapFromData(display,playfield, ob5_bits,
  288.                     block_width, block_height);
  289.  
  290.   tmp_pixmap[OBSRT+5] = XCreateBitmapFromData(display,playfield, ob6_bits,
  291.                     block_width, block_height);
  292.  
  293.   tmp_pixmap[OBSFIN] = XCreateBitmapFromData(display,playfield, ob7_bits,
  294.                     block_width, block_height);
  295.  
  296.   tmp_pixmap[SHOWFLOW] = XCreateBitmapFromData(display,playfield, fbar_bits,
  297.                     fbar_width, fbar_height);
  298.  
  299.   tmp_pixmap[SHOWFLOW+1] = XCreateBitmapFromData(display,playfield, fbar1_bits,
  300.                     fbar_width, fbar_height);
  301.  
  302.   tmp_pixmap[SHOWFLOW+2] = XCreateBitmapFromData(display,playfield, fbar2_bits,
  303.                     fbar_width, fbar_height);
  304.  
  305.   tmp_pixmap[SHOWFLOW+3] = XCreateBitmapFromData(display,playfield, flowst_bits,
  306.                     flowst_width, flowst_height);
  307.  
  308.   tmp_pixmap[START] = XCreateBitmapFromData(display,playfield, start_bits,
  309.                     start_width, start_height);
  310.  
  311.   tmp_pixmap[STARTFULL] = XCreateBitmapFromData(display,playfield, startfull_bits,
  312.                     startfull_width, startfull_height);
  313.  
  314.   tmp_pixmap[ARROW] = XCreateBitmapFromData(display,playfield, arrow_bits,
  315.                     arrow_width, arrow_height);
  316.  
  317.   tmp_pixmap[BAR] = XCreateBitmapFromData(display,playfield, bar_bits,
  318.                     bar_width, bar_height);
  319.  
  320.   XtSetArg(arg,XtNiconPixmap,iconP);
  321.   XtSetValues(top_shell,&arg,1);
  322. }
  323.  
  324.  
  325. /*----------------------------------------------------------------------*/
  326.  
  327. void display_allpixmaps()
  328. {
  329.   /* displays all the pixmaps used to construct the pipe and their filling*/
  330.    int x,y;
  331.    for (x=1 ; x < 10; x++)
  332.      pipe_board[x-1][0]=x;
  333.  
  334.    for (x=2 ; x<8; x++)
  335.      for (y=1; y<6; y++)
  336.         pipe_board[x-2][y]= (x*5) +(y-1);
  337.    x=8;
  338.      for (y=1; y<10; y++)
  339.         pipe_board[x-2][y]= (x*5) +(y-1);
  340.    for (x=9 ; x<11; x++)
  341.      for (y=1; y<6; y++)
  342.         pipe_board[x-2][y]= (x*5) +(y-1) + 5;
  343.    display_level();
  344.  }
  345. /*----------------------------------------------------------------------*/
  346.  
  347. void
  348. display_level()
  349. {
  350. /* Naive refresh algorithm.... */
  351.   int x,y;
  352.  
  353.   XClearWindow(display,playfield);
  354.   for(y=0;y<MAXY;y++)
  355.   {
  356.     for(x=0;x<MAXX;x++)
  357.          if (pipe_board[x][y] < (BAR+1))
  358.         {
  359.             XCopyPlane(display,tmp_pixmap[pipe_board[x][y]],playfield,gc,0,0,
  360.                        block_width,block_height,
  361.                        pos_to_coord(x),pos_to_coord(y),1);
  362.       }
  363.   }
  364.  
  365.   if (INXRANGE(block_x) && INYRANGE(block_y))       /*overlay current block */
  366.    XCopyPlane(display,tmp_pixmap[current_block],playfield,gc,0,0,
  367.         block_width,block_height,
  368.         pos_to_coord(block_x),pos_to_coord(block_y),1);
  369.  
  370. }
  371. /*----------------------------------------------------------------------*/
  372.  
  373. void
  374. redisplay_sequence()
  375. {
  376. /* Naive refresh algorithm.... for sequence */
  377.   int x=(MAXX-2),y;
  378.   for(y=0;y<MAXY;y++)
  379.   {
  380.     if (pipe_board[x][y] < (BAR+1))
  381.         {
  382.             XCopyPlane(display,tmp_pixmap[pipe_board[x][y]],playfield,gc,0,0,
  383.                        block_width,block_height,
  384.                        pos_to_coord(x),pos_to_coord(y),1);
  385.       }
  386.   }
  387.   x = MAXX -3 ; y = MAXY -1;
  388.   if (pipe_board[x][y] < (BAR+1))
  389.         {
  390.             XCopyPlane(display,tmp_pixmap[pipe_board[x][y]],playfield,gc,0,0,
  391.                        block_width,block_height,
  392.                        pos_to_coord(x),pos_to_coord(y),1);
  393.       }
  394. }
  395. /*----------------------------------------------------------------------*/
  396.  
  397. void
  398. redraw_block(x,y)
  399. {
  400. /*redraws a single block*/
  401.   XCopyPlane(display,tmp_pixmap[pipe_board[x][y]],playfield,gc,0,0,
  402.              block_width,block_height,
  403.               pos_to_coord(x),pos_to_coord(y),1);
  404.  
  405. }
  406. /*----------------------------------------------------------------------*/
  407.  
  408. void
  409. show_movement()
  410. {
  411. /* 
  412.  * redraws previous position and overlays current block on new position.
  413.  */
  414.   int x,y;
  415.  
  416.   if (INXRANGE(last_block_x) && INYRANGE(last_block_y))
  417.     redraw_block(last_block_x,last_block_y);
  418.  
  419.   
  420.   if (INXRANGE(block_x) && INYRANGE(block_y))
  421.    XCopyPlane(display,tmp_pixmap[current_block],playfield,gc,0,0,
  422.         block_width,block_height,
  423.         pos_to_coord(block_x),pos_to_coord(block_y),1);
  424.  
  425. }
  426.  
  427. /*----------------------------------------------------------------------*/
  428.  
  429. /*ARGSUSED*/
  430. XtEventHandler
  431. redisplay_level(w, closure, event)
  432.   Widget w;
  433.   caddr_t closure;
  434.   XExposeEvent *event;
  435. {
  436. /* refresh entire screen -- e.g. expose events.  Just a little naive. */
  437.   display_level();
  438.   XFlush(display);
  439. }
  440.  
  441. /*----------------------------------------------------------------------*/
  442.  
  443. void free_pixmaps()
  444. {
  445.   int i;
  446.  
  447.   for(i=0;i++;i<NUM_TMP_CURSOR_PIXMAPS) 
  448.     XFreePixmap(display,tmp_pixmap[i]);
  449.  
  450. }
  451.  
  452.  
  453.  
  454. /*----------------------------------------------------------------------*/
  455.  
  456.  
  457.  
  458.